Gameduino 3X Dazzler

by Excamera Labs

An Arduino shield with a GPU, FPGA, HDMI, and Python support for gaming and audiovisuals

View all updates Oct 15, 2020

Circuit Python

by James B

Graphics is hard. I’m quite pleased with the Gameduino’s usability with the Arduino, and people do sometimes mail me with "hey that was easier than I expected" messages. But this year I’ve been working on another way: a CircuitPython library for the Gameduino.

To be honest, I prefer to use Python for controlling the Gameduino instead of the Arduino. It’s so much quicker to get something running. Of course, you pay a price in speed: Python is slower than C. But very often, your time matters more. This is important whether you’re using it for work or if you want to get something running on Saturday morning.

So here’s a brief walkthrough of CircuitPython on the Dazzler. If you have pledged for the Dazzler Python Game Pack then you can follow along straight out of the box. Connect to the Adafruit Metro M4’s serial console, and type:

>>> import bteve as eve
>>> gd = bteve.Gameduino()
>>> gd.init()

at this point the Gameduino is initialized. You can confirm this by printing out the screen width and height:

>>> gd.w
>>> gd.h

Correct! The Dazzler is indeed 1280x720 pixels. But the screen is black; how about making it bright red:

>>> gd.ClearColorRGB(255, 0, 0)
>>> gd.Clear()

This sets the clear color to bright red — that’s the RGB triple of (255, 0, 0). Then gd.Clear() actually does the clear. After you’ve typed this in, though, the screen doesn’t change. This is because the Gameduino has fancy OpenGL-style double-buffered graphics. You need to tell it to swap this new screen for the old one, like this:

>>> gd.swap()

It begins!

OK, enough of the bright red. How about a nice relaxing triangle instead?

>>> gd.Clear()
>>> gd.Begin(eve.LINE_STRIP)
>>> gd.Vertex2f(100, 100)
>>> gd.Vertex2f(500, 200)
>>> gd.Vertex2f(200, 500)
>>> gd.Vertex2f(100, 100)
>>> gd.swap()

Begin(eve.LINE_STRIP) starts drawing a line strip, a connected series of lines. Then each gd.Vertex2f() draws one corner of the triangle. The fourth call closes the loop.

The Dazzler can do a lot more, of course. It can paint images on the screen almost as easily. First load the image with:

>>> gd.cmd_loadimage(0, 0)
>>> gd.load(open("blinka.png", "rb"))

Then draw it like the triangle above, but with LINE_STRIP changed to BITMAPS:

>>> gd.Clear()
>>> gd.Begin(eve.BITMAPS)
>>> gd.Vertex2f(100, 100)
>>> gd.Vertex2f(500, 200)
>>> gd.Vertex2f(200, 500)
>>> gd.swap()

How about filling the screen with 100 random Blinkas?

>>> import random
>>> gd.Clear()
>>> gd.Begin(eve.BITMAPS)
>>> for i in range(100):
...     gd.Vertex2f(random.randrange(gd.w), random.randrange(gd.h))
>>> gd.swap()

Each Vertex2f() call chooses a random point on the screen, and draws the Blinka sprite there.

It’s as easy as that. Of course the Gameduino can do much more, and the CircuitPython API makes it all quite straightforward. The library will ship with a few small games in CircuitPython, as well as some demos and tutorials. Here’s one I’m currently working on, a match-3 game:

About the Author

James B

 Pescadero, CA

$22,064 raised

of $10,000 goal

220% Funded! Order Below

Product Choices


Dazzler Arduino Shield

A single Dazzler, ready to work with your Arduino or Arduino-like.


Dazzler Python Game Pack

A Dazzler Arduino Shield, an Adafruit Metro M4, a 16 GB microSD card, and two Wii Classic-compatible controllers.


Dazzler Core Pack

Three Dazzler Core modules, and a 0.1" adapter board for easier prototyping.


Excamera Labs

I'm dedicated to building useful hardware and software, particularly where embedded systems meet graphics and imaging. Probably my best known public projects are the Gameduino series of game accessory boards, and the J1 CPU. I have benefited immensely from Open Source hardware and software, so I try to open source as much as I can.

James Bowman

See Also

Subscribe to the Crowd Supply newsletter, highlighting the latest creators and projects: