Title: Reading barcodes with Python and OpenMV - PyImageSearch

URL Source: https://pyimagesearch.com/2018/03/19/reading-barcodes-with-python-and-openmv/

Published Time: 2018-03-19T14:00:53+00:00

Markdown Content:
![Image 1](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20423'%3E%3C/svg%3E)

What if I said that there’s a camera that:

*   Is low cost at **$65**.
*   Runs **MicroPython**.
*   And can be expanded with **shields** just like an Arduino/RPi.

Meet [OpenMV](https://openmv.io/)!

I met Kwabena Agyeman, the founder of OpenMV, during the [PyImageSearch Gurus Kickstarter campaign](https://www.kickstarter.com/projects/adrianrosebrock/pyimagesearch-gurus-become-a-computer-vision-openc) in January 2015. At that time, Kwabena and the OpenMV team were running a [Kickstarter of their own](https://www.kickstarter.com/projects/botthoughts/openmv-cam-embedded-machine-vision). Kwabena’s Kickstarter raised _a lot_ more funds than mine, which really demonstrates (1) the value of the OpenMV product and (2) the eagerness of the embedded community to work with such a tool.

Since the OpenMV Kickstarter, the OpenMV team has been on a mission to **provide a low cost, Python-ready, and easy to use camera system** for developers and engineers working on **embedded computer vision projects.**

Given the success of OpenMV so far, perhaps it’s no surprise that there is an active community of developers. You’ll definitely have the support needed to make your project a success. When I started building the barcode scanning system for this post I was incredibly impressed by the responsiveness of their users and forums.

In today’s blog post, you’ll be introduced to OpenMV, their fancy IDE, and we’ll **even build your own barcode scanning system.**

**To get started with the OpenMV cam and barcode decoding with computer vision, _just keep reading._**

![Image 2](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20128%20128'%3E%3C/svg%3E)

#### Looking for the source code to this post?

[Jump Right To The Downloads Section](#download-the-code)

[![Image 3](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20300%20295'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv-barcode-py-barcode.jpg)

**Figure 1:** The OpenMV can read QR codes among many types of codes — all with built in libraries!

There’s no way of getting around barcodes in today’s world.

Every grocery item or Amazon package you receive has them. Every time you board an airplane or rent a car, barcodes are used. And heaven forbid, the a barcode could be associated with your identity on a hospital wristband during an emergency visit!

But why?

Simply put, barcodes are an easy way for computers to associate an item with a database. It’s therefore important that barcodes are decoded properly so that databases can be updated.

Typical barcode readers use a photoelectric cell to “see” the code. Check out this post by Chris Woodford on _[Barcodes and barcode scanners](http://www.explainthatstuff.com/barcodescanners.html)_.

Given the prominence of cameras in today’s age, we can actually use image processing to detect and decode barcodes.

In a previous post here on PyImageSearch, I demonstrated [how to detect barcodes with Python and OpenCV](https://pyimagesearch.com/2014/11/24/detecting-barcodes-images-python-opencv/).

Detecting is one piece of the puzzle.

The other piece is _decoding_ the barcode into a useful string.

Unfortunately, OpenCV does not contain built-in barcode detection + reading functionality…

…but there are a few popular libraries for barcode detection, one of which is [ZBar](http://zbar.sourceforge.net/). Satya Mallick, a [PyImageConf 2018](https://www.pyimageconf.com/) presenter, wrote a great post about ZBar [last month on his blog](https://www.learnopencv.com/barcode-and-qr-code-scanner-using-zbar-and-opencv/).

Using ZBar and other similar barcode reading libraries is one method to accomplish the task.

**The other option is to use embedded tools and libraries such as OpenMV.**

In fact, OpenMV makes it _so easy_ to detect and read barcodes that you could:

*   Build your own barcode scanning device
*   Create an automated part inspection system on an assembly line
*   Utilize OpenMV in a hobby project to help you scan and organize components and peripherals in your workshop
*   Use OpenMV to teach middle school or high schoolers about embedded programming

### The OpenMV cam

[![Image 4](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20400%20414'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv_cam_and_logo.jpg)

**Figure 2:** The OpenMV camera is a powerful embedded camera board that runs MicroPython.

Aimed at being the _**“Arduino of Machine Vision”**_, the OpenMV cam is embedded (no OS) and is expandable via several available shields (just like an [Arduino](https://www.arduino.cc/)).

It is also dead-simple to use — you write code with [MicroPython](https://micropython.org/) (unlike an Arduino).

Python users and readers of this blog will feel at home when building embedded computer vision projects with MicroPython for the OpenMV.

The OpenMV camera is quite capable and would fit well in a small robotics project with servo motors or even in a automated part inspection assembly line.

You can easily interface the OpenMV with other hardware, sensors, microcontrollers, and SBCs over communication protocols such as SPI, I2C, WiFi, and USB.

**OpenMV will typically work best if it just has one or two tasks to perform as it does have limited memory** (31KB is allocated for scripts). If you need to record stills or video you may plug in a microSD.

Image processing capabilities of the OpenMV include:

*   Haar cascades
*   Thresholding
*   Blob detection
*   Drawing lines, circles, and rectangles
*   Recording GIFs and MJPEGs
*   Reading barcodes (this post)
*   Template matching
*   _…and more!_

For the full list, be sure to [check out the docs](http://docs.openmv.io/library/index.html#libraries-specific-to-the-openmv-cam).

Do you need a particular lens for your application? One differentiator is the **Standard M12 Lens Mount**. Now you can attach that telescopic zoom or fisheye lens for your project. I sure do wish that the Raspberry Pi PiCamera has a lens mount like the OpenMV does.

### Barcode detection and decoding with OpenMV and Python

Once you’ve installed the OpenMV IDE, fire it up. We’ll be doing all of our coding in the **OpenMV IDE**.

Let’s begin by creating a file called `openmv_barcode.py` :

\# import necessary packages
import sensor
import time
import image

# import the lcd optionally
# to use the LCD, uncomment Lines 9, 24, 33, and 100
# and comment Lines 19 and 20 
#import lcd

On **Lines 2-4** we import our required MicroPython/OpenMV packages.

Optionally, on **Line 9**, you can import the `lcd` package which is required if you want to use the LCD shield.

Next, let’s set up the camera sensor:

\# reset the camera
sensor.reset()

# sensor settings
sensor.set\_pixformat(sensor.GRAYSCALE)

# non LCD settings
# comment the following lines if you are using the LCD
sensor.set\_framesize(sensor.VGA)
sensor.set\_windowing((640, 240))

# LCD settings
# uncomment this line to use the LCD with valid resolution
#sensor.set\_framesize(sensor.QQVGA2)

# additional sensor settings
sensor.skip\_frames(2000)
sensor.set\_auto\_gain(False)
sensor.set\_auto\_whitebal(False)

The settings on **Lines 12-29** are self explanatory, so please read the code and comments.

I do want to point out that the LCD requires a resolution that fits the screen (`sensor.QQVGA2` ).

_**Note:** I tried and tried to figure out how to use the full resolution and then make a scaled image which would fit on the LCD, but was unable. Because of this, if you do elect to use the LCD, you’ll be trying to decode barcodes at a lower resolution (which isn’t optimal for traditional 1D barcodes). Needless to say, the LCD is still a good debugging tool, and I wanted to include it so that you can see that it’s very easy to use. As always, if you are able to solve this problem, then I encourage you to leave me a comment below the post to share with me and the community._

I’d also like to point out **Line 27**. In the “hello world” example you’ll see a keyword argument `time=2000` to `sensor.skip_frames` . Keyword arguments aren’t supported in this context, so be sure to use this syntax shown on **Line 27** (especially if you are working through the “hello world”).

Next, let’s perform initializations:

\# initialize the LCD
# uncomment if you are using the LCD
#lcd.init()

# initialize the clock
clock = time.clock()

You’ll want to uncomment **Line 33** if you are using the LCD (see the previous code block).

**Line 36** initialize our clock for FPS calculations

From there we’ll create (1) a lookup table and (2) a convenience function for determining the type of barcode:

\# barcode type lookup table
barcode\_type = {
	image.EAN2: "EAN2",
	image.EAN5: "EAN5",
	image.EAN8: "EAN8",
	image.UPCE: "UPCE",
	image.ISBN10: "ISBN10",
	image.EAN13: "EAN13",
	image.ISBN13: "ISBN13",
	image.I25: "I25",
	image.DATABAR: "DATABAR",
	image.DATABAR\_EXP: "DATABAR\_EXP",
	image.CODABAR: "CODABAR",
	image.CODE39: "CODE39",
	image.PDF417: "PDF417",
	image.CODE93: "CODE93",
	image.CODE128: "CODE128"
}

def barcode\_name(code):
	# if the code type is in the dictionary, return the value string
	if code.type() in barcode\_type.keys():
		return barcode\_type\[code.type()\]

	# otherwise return a "not defined" string
	return "NOT DEFINED"

As you can see on **Lines 39**, where I defined a `barcode_type` dictionary, the OpenMV can detect and decode quite a few different barcode styles.

That being said, I didn’t have luck with all of them, so the PDF included with the _**“Downloads”**_ section of this blog post doesn’t include every type of barcode.

**Lines 57-63** define a convenience function for grabbing the barcode type without risk of throwing a Python key exception (the OpenMV does not handle exceptions well).

From there, let’s get down to business and start capturing and processing frames! We’ll begin by starting a `while` loop:

\# loop over frames and detect + decode barcodes
while True:
	# tick the clock for our FPS counter
	clock.tick()

	# grab a frame
	img = sensor.snapshot()

The first step is to tick the clock for our FPS counter (**Line 68**).

From there you should grab a frame with `sensor.snapshot` (**Line 71**).

Now, let the fun begin!

We’ve got an image, so let’s see what we can do with it:

	# loop over standard barcodes that are detected in the image
	for code in img.find\_barcodes():
		# draw a rectangle around the barcode
		img.draw\_rectangle(code.rect(), color=127)

		# print information in the IDE terminal
		print("type: {}, quality: {}, payload: {}".format(
			barcode\_name(code),
			code.quality(),
			code.payload()))

		# draw the barcode string on the screen similar to cv2.putText
		img.draw\_string(10, 10, code.payload(), color=127)

Here we’re finding standard, non-QR codes. All we need to do is call `img.find_barcodes` (which encapsulates all barcode detection + reading functionality) and loop over the results (**Line 74**).

Given the detected barcodes we can:

*   Draw a bounding box rectangle around the detected barcode (**Line 76**).
*   Print the type, quality, and payload (**Lines 79-82**).
*   Draw the string on the screen (**Line 85**). Unfortunately (according to the [docs](http://docs.openmv.io/library/omv.image.html?highlight=draw_string#image.image.draw_string)) there is no current way to draw the string in a larger font.

That’s really all there is to it!

QR code decoding is done in a similar fashion:

	# loop over QR codes that are detected in the image
	for code in img.find\_qrcodes():
		# draw a rectangle around the barcode
		img.draw\_rectangle(code.rect(), color=127)

		# print information in the IDE terminal
		print("type: QR, payload: {}".format(code.payload()))

		# draw the barcode string on the screen similar to cv2.putText
		img.draw\_string(10, 10, code.payload(), color=127)

	# display the image on the LCD
	# uncomment if you are using the LCD
	#lcd.display(img)

	# print the frames per second for debugging
	print("FPS: {}".format(clock.fps()))

This loop mimics the standard barcode loop, so be sure to review it for details.

Outside of the loop, if you’re using the LCD, you’ll want to display on it (**Line 100**).

Lastly, we can easily print the FPS (frames per second) in the terminal on **Line 103**.

### OpenMV Barcode Decoding Results.

[![Image 5](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20447'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv-ide.jpg)

**Figure 3:** The OpenMV team has put together an awesome **IDE for computer vision development**. This is what you see when you first open the IDE and load a program.

First, connect your OpenMV cam via USB to your computer.

Then Fire up the IDE as shown in **Figure 3**.

From there, click the connect button in the lower left.

The IDE may prompt you to update your firmware (which I did without a hitch by clicking the button and waiting about 3-5 minutes).

When you’re ready with your program loaded in the editor, click the green play/program button also in the lower left. This button will set up the OpenMV with your code.

**Be patient.** It takes about 45-90 seconds for the MicroPython code to compile to machine code and get flashed on the processor. _There isn’t a status indicator, so you just need to be patient._

Before long, if you’re printing to the terminal, you’ll see the data such as FPS or barcode information — that’s your queue that everything is working. You’ll also see a live view from the camera sensor in the top right viewfinder.

Now let’s try some barcodes!

In the _**“Downloads”**_ section, I’ve included a PDF of barcodes for you to print and scan. Here’s what we’re working with:

[![Image 6](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20350%20468'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv-barcodes-pdf-screenshot.jpg)

**Figure 4:** Sample barcodes for testing with the OpenMV camera. Included are QR, CODE128, CODE93, CODE39, and DATABAR barcode images. You may print a PDF from the “Downloads” section of this blog post.

You can see the results here from the IDE’s built in terminal:

FPS: 2.793296
type: QR, payload: https://pyimagesearch.com/
FPS: 2.816901
type: QR, payload: https://openmv.io/
FPS: 2.941176
type: QR, payload: http://pyimg.co/dl4cv
FPS: 3.831418
type: CODE128, quality: 48, payload: guru
FPS: 4.484305
ype: CODE93, quality: 15, payload: OpenMV
FPS: 3.849856
type: CODE39, quality: 68, payload: DL4CV
FPS: 3.820961
type: DATABAR, quality: 83, payload: 0100000000020183
FPS: 4.191617

Screenshots of each code and the terminal are below:

[![Image 7](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20400%20564'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv_bc1_crop.jpg)

**Figure 5:** Scanning a **QR** code with a link to the PyImageSearch homepage.

[![Image 8](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20400%20557'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv_bc2_crop.jpg)

**Figure 6:** Scanning a **QR** code that contains a payload of “https://openmv.io” — the OpenMV homepage.

[![Image 9](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20400%20560'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv_bc3_crop.jpg)

**Figure 7:** This **QR** code contains a payload directing you to the [_Deep Learning for Computer Vision with Python_ book](https://pyimagesearch.com/2017/09/23/getting-started-deep-learning-computer-vision-python/) information page.

[![Image 10](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20400%20554'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv_bc4_crop.jpg)

**Figure 8:** A **CODE128** barcode that says “guru” is decoded by the OpenMV.

[![Image 11](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20400%20567'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv_bc5_crop.jpg)

**Figure 9:** The OpenMV can decode **CODE93** barcodes such as this one that has a payload of “OpenMV”.

[![Image 12](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20400%20571'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv_bc6_crop.jpg)

**Figure 10:** **CODE39** barcodes are easy with the OpenMV. The Payload here is “DL4CV”.

[![Image 13](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20400%20565'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv_bc7_crop.jpg)

**Figure 11:** The OpenMV can decode **DATABAR** codes which are fixed-width and only contain digits. I coded “2018” into this barcode, but as you can see, the OpenMV camera actually reads 16 characters.

And finally, here’s a picture of the IDE in action. Notice how it is reading multiple codes, drawing boxes around the barcodes, and also contains a nice color histogram.

[![Image 14](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20447'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv-live.jpg)

**Figure 12:** The OpenMV in action detecting barcodes and printing results to the IDE. As you can see, there’s a terminal in the bottom left which is scrolling data. There’s also a live view of the camera feed in the top right of the IDE and color histograms in the bottom right.

Here’s a video of the system in action using the IDE:

The IDE is great for debugging. For a deployable project however, you wouldn’t use the IDE. Instead you’d send the barcode payloads out to an actuator via I2C, SPI, or maybe WiFi to be processed in a database.

The LCD tool is also great for debugging although I found that the required resolution didn’t work for all the barcodes on the `barcodes.pdf`  file included in the _**“Downloads”**_.

Nevertheless, here’s the LCD in action:

[![Image 15](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20400%20392'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv_lcd_shield_view.jpg)

**Figure 13:** The OpenMV color LCD shield provides a nice viewfinder for the OpenMV. Pictured are a few barcodes for today’s blog post on decoding barcodes with the openMV.

### Does the OpenMV run OpenCV?

**In short, no — the OpenMV does not run OpenCV.** The processor wouldn’t be able to handle it.

There are a number of capabilities of the OpenMV, but don’t think of it as a replacement for a Raspberry Pi which can run an OS and OpenCV.

But don’t let that deter you from considering the OpenMV for your project!

There’s _plenty_ of OpenCV-like functionality built in.

You’ll feel at home working with the OpenMV examples and turning one into a solution that works in your project, **but don’t expect to paste some OpenCV code into the OpenMV IDE and expect it to work.**

Oh, and the best part?

You don’t need to worry about a complex install! If the OpenMV firmware needs to be updated, just click the button in the IDE and it will update over USB in a matter of minutes.

The easy install, and basic image processing capabilities make it a great teaching tool to get someone interested in CV.

It also would do well in specific projects, provided the project aligns with one of the image processing capabilities of OpenMV — just be sure that you don’t need something more powerful before you go down this path.

### Can I connect the OpenMV to my Raspberry Pi?

Of course you _can_ but there are more reasons against doing so.

The first reason is: the Raspberry Pi can do (mostly) everything the OpenMV can do, and then some. I2C? Check. SPI? Check. PWM? Check. WiFi? Check.

That said, the Raspberry Pi _doesn’t_ have a high powered RGB LED and two high power IR LEDs like the OpenMV does.

But back to the point: **Why would you need duplicate capabilities?**

You most-likely don’t.

Instead, you should _not_ think of the OpenMV as a general purpose SBC — it’s not.

The OpenMV is particularly great for _specific embedded use cases_. Another great use case for the OpenMV might be one where you’re concerned about power draw such as on a battery powered drone.

The second reason is that compiling the QT GUI for the Raspberry Pi would take 2-3 days. This isn’t practical. Sure you could do it once, and keep a handy .img lying around so you don’t have to do it again, but it just doesn’t seem practical to me.

So yes — you can definitely plug in the OpenMV via USB or via a custom header/wires to a Raspberry Pi. I just don’t think it is the wise thing to do.

If I’m wrong, let’s discuss in the comments section.

### Where can I get an OpenMV camera as well as accessories?

[![Image 16](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20500%20331'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv-where-to-buy.jpg)

**Figure 7:** The OpenMV is available at **distributors** as well as **direct** at [openmv.io](http://openmv.io/). Bulk discounts and kits are available!

The OpenMV is very affordable at **$65**. Think of it as getting a powerful Arduino and a camera all on one board (that runs MicroPython).

You can pick up an OpenMV Cam at the retailers listed on the [sales page](https://openmv.io/collections/products), and many of the retailers offer free shipping.

Notable retailers include

*   [SparkFun](https://www.sparkfun.com/products/14632) (for $65, it comes with plastic case and headers)
*   [Seed Studio](https://www.seeedstudio.com/OpenMV-Cam-M7-p-2855.html)
*   [Robot Shop](https://www.robotshop.com/en/openmv-cam-m7-image-sensor.html)

There are a few Chinese retailers serving Asia as well as a number of European and UK retailers.

**Looking to buy in bulk for your classroom or for a deployment?**

If that’s the case, then you can take advantage of the bulk discounts by ordering direct from OpenMV.io. There’s a piecewise function where you can get 10%, 20%, or even 30% off by buying in bulk.

**Shields, shields, shields!**

[![Image 17](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20385'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv_shields.jpg)

**Figure 8:** The OpenMV has an assortment of shields available to expand capabilities. Do you want to make your own shield? The hardware is open source, so get started with Eagle CAD or your favorite tool.

There are a number of expansion shields available, so be sure to check the retailers as well as OpenMV direct for purchasing options.

The official shields include:

*   WiFi Shield (supports streaming video at 48 Mbps)
*   [LCD Shield](https://openmv.io/products/lcd-shield) (color!)
*   [Servo Shield](https://openmv.io/products/servo-shield) (supports up to 8 servos!)
*   [Motor Shield](https://openmv.io/products/motor-shield) (motors, solenoids, or other electromechanicals up to 2A)
*   [Proto Shield](https://openmv.io/products/proto-shield) (connect I/O such as a sensor to your OpenMV processor)
*   [Thermopile Shield](https://openmv.io/collections/shields/products/thermopile-shield) (thermal camera shield — it’s no longer sold, but still supported if you can find one)

You’ll need to use your soldering skills in order to attach shields — the headers do not come pre-populated. This is a minor inconvenience, but if you have a soldering iron, you can be up and running in 10 minutes.

It’s also worth noting that _**all hardware is open source**_. So if you have electronics skills and need a custom shield and are proficient in Eagle CAD, then you can visit the [OpenMV Shield GitHub Repo](https://github.com/openmv/openmv-boards/tree/master/shields) to select a shield as a starting point to customize for your application.

**Do you want a value kit that includes most accessories so you can get started tinkering?**

If you order the [“F](https://openmv.io/products/full-set)ull Set” kit direct from OpenMV.io, you get about **10% off the combined price**.

The “Full Set” kit includes 7 pieces:

*   1 – OpenMV Cam M7
*   3 – Shields (Proto Shield, LCD Shield, WiFi Shield)
*   3 – Lenses (IR Lens, Telephoto Lens, Ultra Wide Angle Lens)

[![Image 18](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20450%20393'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2018/03/openmv_fullset.jpg)

**Figure 9:** The OpenMV Full Set bundle is a good kit to get started with. It is 10% off versus buying the items individually.

### What's next? We recommend [PyImageSearch University](https://pyimagesearch.com/pyimagesearch-university/?utm_source=blogPost&utm_medium=bottomBanner&utm_campaign=What%27s%20next%3F%20I%20recommend).

**Course information:**  
84 total classes • 114+ hours of on-demand code walkthrough videos • Last updated: February 2024  
★★★★★ 4.84 (128 Ratings) • 16,000+ Students Enrolled

**I strongly believe that if you had the right teacher you could _master_ computer vision and deep learning.**

Do you think learning computer vision and deep learning has to be time-consuming, overwhelming, and complicated? Or has to involve complex mathematics and equations? Or requires a degree in computer science?

That’s _not_ the case.

All you need to master computer vision and deep learning is for someone to explain things to you in _simple, intuitive_ terms. _And that’s exactly what I do_. My mission is to change education and how complex Artificial Intelligence topics are taught.

If you're serious about learning computer vision, your next stop should be PyImageSearch University, the most comprehensive computer vision, deep learning, and OpenCV course online today. Here you’ll learn how to _successfully_ and _confidently_ apply computer vision to your work, research, and projects. Join me in computer vision mastery.

**Inside PyImageSearch University you'll find:**

*   ✓ **84 courses** on essential computer vision, deep learning, and OpenCV topics
*   ✓ **84 Certificates** of Completion
*   ✓ **114+ hours** of on-demand video
*   ✓ **Brand new courses released _regularly_**, ensuring you can keep up with state-of-the-art techniques
*   ✓ **Pre-configured Jupyter Notebooks in Google Colab**
*   ✓ Run all code examples in your web browser — works on Windows, macOS, and Linux (no dev environment configuration required!)
*   ✓ Access to **centralized code repos for _all_ 536+ tutorials** on PyImageSearch
*   ✓ **Easy one-click downloads** for code, datasets, pre-trained models, etc.
*   ✓ **Access** on mobile, laptop, desktop, etc.

[Click here to join PyImageSearch University](https://pyimagesearch.com/pyimagesearch-university/?utm_source=blogPost&utm_medium=bottomBanner&utm_campaign=What%27s%20next%3F%20I%20recommend)

Summary
-------

In today’s blog post we used the [OpenMV](https://openmv.io/) to perform barcode decoding.

Aimed at being the _**“Arduino of Machine Vision”**_, the OpenMV cam is embedded (no OS) and is expandable via several available shields. It’s also extremely easy to use. You can write code on the OpenMV using MicroPython.

However, it’s important to understand that the OpenMV _does not_ run OpenCV — the processor simply would not be able to handle it. That said, there’s _plenty_ of OpenCV-like functionality built in. Using the OpenMV IDE you can put together your own computer vision applications.

Next week I’ll be interviewing Kwabena Agyeman, the creator of OpenMV.

**To be notified when next week’s interview with Kwabena goes live, _just enter your email address in the form below!_**

![Image 19](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20410%20567'%3E%3C/svg%3E)

#### Download the Source Code and FREE 17-page Resource Guide

Enter your email address below to get a .zip of the code and a **FREE 17-page Resource Guide on Computer Vision, OpenCV, and Deep Learning.** Inside you'll find my hand-picked tutorials, books, courses, and libraries to help you master CV and DL!