The Arduino GIGA R1 WiFi is unusual among Arduino boards because it combines high-performance processing with dedicated hardware for:
- camera input;
- high-resolution displays;
- touch interfaces;
- stereo analogue audio output;
- microphone input;
- large framebuffers.
At the centre of the board is the:
|
1 2 3 4 5 6 |
STM32H747XI Cortex-M7 up to 480 MHz Cortex-M4 up to 240 MHz |
supported by:
|
1 2 3 4 5 6 |
1 MB internal RAM 8 MB external SDRAM 16 MB external QSPI Flash |
That combination makes the GIGA much better suited to multimedia work than a traditional UNO, Mega or Due.
Quick Multimedia Reference
| Feature | GIGA R1 WiFi |
|---|---|
| Camera connector | 20-pin dedicated connector |
| Supported Arduino camera families | OV7670, OV7675, GC2145, HM01B0 |
| Camera digital pins | D54-D67 |
| Display connector GPIO | D68-D75 plus dedicated DSI signals |
| External SDRAM | 8 MB |
| External Flash | 16 MB |
| GIGA Display Shield | 3.97-inch 480×800 / 800×480 orientation, touch |
| Display libraries | Arduino_H7_Video, LVGL, GFX, ArduinoGraphics |
| Touch library | Arduino_GigaDisplayTouch |
| Audio output | 2 × 12-bit DAC |
| DAC0 | A12 / D84 / right audio channel |
| DAC1 | A13 / D85 / left audio channel |
| Microphone input | A7 / D83 |
| Audio connector | 3.5 mm TRRS |
Why the 8 MB SDRAM Matters
Large displays and cameras consume RAM quickly.
For example, a:
|
1 2 3 4 5 |
800 × 480 16-bit RGB565 framebuffer |
requires approximately:
|
1 2 3 4 5 6 |
800 × 480 × 2 = 768,000 bytes ≈ 750 kB |
A double-buffered display can therefore consume around:
|
1 2 3 4 |
1.5 MB |
before any application data, networking or graphics assets are considered.
The GIGA’s:
|
1 2 3 4 |
8 MB SDRAM |
makes these workloads practical.
Camera Connector
The GIGA includes a dedicated:
|
1 2 3 4 |
20-pin camera connector |
designed to accept compatible camera breakout boards directly.
Arduino’s current Camera library supports:
- OV7670;
- OV7675;
- GC2145;
- Himax HM01B0.
The connector provides:
- 3.3 V;
- ground;
- I2C control;
- parallel image data;
- pixel clock;
- horizontal reference;
- vertical synchronisation;
- camera power/control signals.
Camera Connector Digital Mapping
The camera connector uses:
|
1 2 3 4 |
D54-D67 |
for the major camera signals.
The current GIGA pinout maps:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
D54 → VSYNC D55 → camera signal D56 → PCLK D57 → camera signal D58-D65 → image data / camera signals D66 → camera power/control D67 → camera power/control |
The official connector also duplicates D66 and D67 on the 20-pin header.
Camera I2C
The camera connector includes the dedicated I2C control signals:
|
1 2 3 4 5 |
SCL1 SDA1 |
These are used to configure camera registers such as:
- resolution;
- frame rate;
- exposure;
- colour format;
- sensor operating mode.
The Camera Library Is Included with the GIGA Board Core
Arduino’s current camera workflow uses the:
|
1 2 3 4 |
Camera |
library bundled with the Arduino Mbed board package.
A typical OV7670 declaration begins:
|
1 2 3 4 5 6 7 8 |
#include "camera.h" #include "ov767x.h" OV7670 sensor; Camera camera(sensor); |
For an OV7675, the sensor class can be changed accordingly.
Camera Image Formats
The official GIGA camera example uses formats such as:
|
1 2 3 4 |
RGB565 |
for colour cameras.
Other supported camera modules can provide grayscale output.
RGB565 is useful because each pixel uses:
|
1 2 3 4 5 |
16 bits 2 bytes |
which balances memory use and colour quality.
Camera Frame Memory Adds Up Quickly
A 320 × 240 RGB565 frame requires:
|
1 2 3 4 5 |
320 × 240 × 2 = 153,600 bytes |
A 640 × 480 RGB565 frame would require:
|
1 2 3 4 5 |
640 × 480 × 2 = 614,400 bytes |
This is another reason the GIGA’s external SDRAM is important.
Stream a Camera Image over Web Serial
Arduino provides an official example that:
|
1 2 3 4 5 6 7 8 |
camera → capture frame → USB Serial → browser Web Serial → canvas display |
The example is available through the Camera examples in the Arduino IDE.
This is useful for testing a camera without first adding a physical display.
Camera Plus Display
The more interesting GIGA configuration is:
|
1 2 3 4 5 6 7 |
camera → GIGA → framebuffer → display |
This can be used for:
- machine vision previews;
- inspection systems;
- robot cameras;
- door-entry systems;
- embedded dashboards;
- image-processing experiments.
Dedicated Display Connector
Next to the camera interface, the GIGA includes a dedicated display connector.
The general-purpose display GPIO group is:
|
1 2 3 4 |
D68-D75 |
and the connector also includes dedicated high-speed:
|
1 2 3 4 5 6 |
DSI_D0 DSI_D1 DSI clock |
differential signals.
DSI Pins Are Not Normal GPIO
The official GIGA pinout explicitly warns that the dedicated DSI signals are:
|
1 2 3 4 |
display-only |
and should not be treated as:
- ordinary digital GPIO;
- analogue inputs;
- general-purpose header pins.
GIGA Display Shield
The easiest way to use the display interface is Arduino’s:
|
1 2 3 4 |
GIGA Display Shield |
which attaches directly to the board.
It provides a:
|
1 2 3 4 5 6 7 8 |
3.97-inch 480 × 800 portrait or 800 × 480 landscape RGB touch display |
capable of displaying up to:
|
1 2 3 4 |
16.7 million colours |
The Display Shield Adds More Than a Screen
The shield also includes:
- capacitive touch;
- MP34DT06JTR digital MEMS microphone;
- Bosch BMI270 6-axis IMU;
- RGB LED;
- camera connector.
This makes it a useful HMI platform rather than simply an LCD panel.
Arduino_H7_Video
The main Arduino video/display layer is:
|
1 2 3 4 |
Arduino_H7_Video |
which is included with the GIGA board package.
A typical initialisation is:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
#include "Arduino_H7_Video.h" Arduino_H7_Video Display( 800, 480, GigaDisplayShield ); void setup() { Display.begin(); } void loop() { } |
Touch Support
For touch input, use:
|
1 2 3 4 5 6 |
#include "Arduino_GigaDisplayTouch.h" Arduino_GigaDisplayTouch Touch; |
and initialise it with:
|
1 2 3 4 |
Touch.begin(); |
LVGL
The GIGA Display Shield supports:
|
1 2 3 4 |
LVGL |
which is useful for sophisticated graphical interfaces containing:
- buttons;
- sliders;
- charts;
- gauges;
- animations;
- menus;
- touch controls.
Basic LVGL Display Setup
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
#include "Arduino_H7_Video.h" #include "Arduino_GigaDisplayTouch.h" #include "lvgl.h" Arduino_H7_Video Display( 800, 480, GigaDisplayShield ); Arduino_GigaDisplayTouch Touch; void setup() { Display.begin(); Touch.begin(); } void loop() { lv_timer_handler(); } |
Other Graphics Libraries
Arduino also documents support for:
- GFX;
- ArduinoGraphics;
- LVGL;
- emWin;
- AppWizard-based workflows.
This gives you a choice between lightweight drawing and full UI frameworks.
Camera Feed on the GIGA Display Shield
Arduino provides examples that combine:
|
1 2 3 4 5 6 |
camera input + GIGA Display Shield |
including OpenMV-based workflows.
The high-level pipeline is:
|
1 2 3 4 5 6 7 8 |
camera sensor → capture buffer → image processing → display framebuffer → LCD |
Use the M7 for Graphics
For dual-core projects, the:
|
1 2 3 4 |
Cortex-M7 |
is the natural place for:
- camera acquisition;
- display rendering;
- large framebuffers;
- LVGL;
- USB;
- Wi-Fi;
- image processing.
Use the M4 for Real-Time Control
The:
|
1 2 3 4 |
Cortex-M4 |
can then handle:
- motors;
- sensors;
- CAN;
- timing-sensitive control;
- background acquisition.
The cores can exchange status and commands through RPC.
Audio Hardware
The GIGA has a built-in:
|
1 2 3 4 |
3.5 mm TRRS audio jack |
connected to:
|
1 2 3 4 5 6 |
DAC0 DAC1 A7 microphone input |
This allows the board to both generate and capture analogue audio signals.
DAC0 and DAC1
The two STM32H747 DAC channels are:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
DAC0 → A12 → D84 → right audio channel DAC1 → A13 → D85 → left audio channel |
Each DAC supports:
|
1 2 3 4 |
up to 12-bit resolution |
Microphone Input
The microphone input on the 3.5 mm jack is shared with:
|
1 2 3 4 5 6 |
A7 → D83 → PA0 |
That means the same analogue channel used as A7 is electrically connected to the microphone path on the jack.
Do Not Drive a Passive Speaker Directly
This is one of the most important audio warnings.
The GIGA does:
|
1 2 3 4 |
not |
include a power amplifier for a speaker.
Arduino explicitly warns that directly connecting a non-amplified speaker can damage:
- the DAC;
- the GIGA board.
Use:
- an active/powered speaker;
- a line-level amplifier;
- a suitable audio amplifier stage.
Arduino_AdvancedAnalog
For high-performance ADC/DAC applications, Arduino provides:
|
1 2 3 4 |
Arduino_AdvancedAnalog |
This library supports configuration of:
- resolution;
- sample rate;
- buffer size;
- queue depth;
- DMA-driven ADC/DAC operation.
Generate a DAC Waveform
A simple buffered DAC configuration can start with:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
#include <Arduino_AdvancedAnalog.h> AdvancedDAC dac0(A12); void setup() { if (!dac0.begin( AN_RESOLUTION_12, 8000, 32, 64)) { while (1) { } } } |
This configures:
|
1 2 3 4 5 6 7 |
12-bit output 8 ksample/s 32 samples per buffer queue depth 64 |
Fill a DAC Buffer
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
void loop() { if (dac0.available()) { SampleBuffer buffer = dac0.dequeue(); for (int i = 0; i < buffer.size(); i++) { buffer[i] = (i & 1) ? 0xFFF : 0x000; } dac0.write(buffer); } } |
This demonstrates DMA/buffer-oriented waveform generation rather than repeatedly calling a slow single-sample function.
Generate Sine, Square and Sawtooth Waves
The same architecture can produce:
- sine;
- square;
- triangle;
- sawtooth;
- arbitrary lookup-table waveforms.
This makes the GIGA useful for:
- synthesizers;
- signal generators;
- control voltages;
- test equipment;
- audio experiments.
Advanced ADC
The STM32H747 contains three ADC blocks with configurable resolutions.
Arduino’s AdvancedAnalog library supports acquisition with parameters such as:
|
1 2 3 4 5 6 7 |
resolution sample rate samples per channel queue depth |
For example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#include <Arduino_AdvancedAnalog.h> AdvancedADC adc(A0); void setup() { adc.begin( AN_RESOLUTION_16, 16000, 32, 64 ); } |
This is significantly more sophisticated than the simple:
|
1 2 3 4 |
analogRead() |
workflow.
USB Audio Playback
The GIGA can combine its multimedia features into:
|
1 2 3 4 5 6 7 8 9 |
USB flash drive → WAV file → buffer → DAC → audio jack → amplified speaker |
Arduino’s official workflow uses:
- Arduino_AdvancedAnalog;
- Arduino_USBHostMbed5;
- FATFileSystem;
- USBHostMSD.
USB Drive Format
For the official WAV playback example, Arduino specifies a USB storage device formatted as:
|
1 2 3 4 5 |
FAT32 MBR partitioning |
The USB-A port is then used as the host interface.
Why Multimedia Work Benefits from Dual Core
A complex GIGA application might need to do all of this simultaneously:
|
1 2 3 4 5 6 7 8 9 10 11 |
camera display touch audio Wi-Fi sensors motor control CAN |
Trying to place all time-critical and high-level work into one loop can make the application harder to maintain.
A better design is:
M7
|
1 2 3 4 5 6 7 8 9 |
camera display LVGL Wi-Fi USB storage audio playback |
M4
|
1 2 3 4 5 6 7 |
motor loops sensor acquisition CAN real-time I/O |
Common Mistake 1: Treating DSI Signals as GPIO
The dedicated DSI differential pairs are display signals only.
Do not treat them as:
|
1 2 3 4 |
normal Dxx pins |
even though they appear on the physical display connector.
Common Mistake 2: Connecting the Camera from the Wrong Side
The GIGA pinout explicitly warns:
|
1 2 3 4 5 |
do not connect the camera from the bottom side |
Follow the official connector orientation for the camera module.
Common Mistake 3: Forgetting Shared Pins
The camera/display expansion system shares some signals with other board functions.
For example, the camera I2C bus is shared with:
|
1 2 3 4 5 |
SCL1 SDA1 |
on the board headers.
Do not independently attach conflicting devices without considering bus addresses and ownership.
Common Mistake 4: Running Out of RAM
Camera and display buffers become large very quickly.
Calculate memory before choosing:
- resolution;
- colour depth;
- double buffering;
- camera frame count;
- UI assets.
Common Mistake 5: Driving a Speaker Directly
The DAC is:
|
1 2 3 4 |
signal output |
not a speaker power amplifier.
Use amplified audio hardware.
Common Mistake 6: Using Blocking Code in a UI Loop
LVGL and similar frameworks need regular servicing.
A long:
|
1 2 3 4 |
delay() |
or blocking camera/network operation can make the UI appear frozen.
Use:
- non-blocking state machines;
- threads;
- dual-core task separation;
- buffered I/O.
Quick Camera Reference
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
Connector: 20-pin camera header Supported camera families: OV7670 OV7675 GC2145 HM01B0 Camera GPIO: D54-D67 Control: SCL1 / SDA1 Library: Camera bundled with Arduino Mbed core Typical colour format: RGB565 |
Quick Display Reference
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
Display connector: D68-D75 + dedicated DSI lanes GIGA Display Shield: 3.97-inch 480×800 portrait 800×480 landscape touch Libraries: Arduino_H7_Video Arduino_GigaDisplayTouch LVGL GFX ArduinoGraphics |
Quick Audio Reference
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
3.5 mm TRRS jack DAC0: A12 D84 PA4 right channel DAC1: A13 D85 PA5 left channel Microphone: A7 D83 PA0 DAC resolution: up to 12-bit Advanced library: Arduino_AdvancedAnalog Important: use amplified speaker / amplifier do not directly drive a passive speaker |
Final Thoughts
The GIGA R1 WiFi is one of the few Arduino boards that can realistically combine:
- camera capture;
- large graphical UI;
- touch input;
- stereo DAC output;
- microphone input;
- USB storage;
- Wi-Fi;
- real-time control.
The hardware that makes this possible is the combination of:
|
1 2 3 4 5 6 7 8 9 10 11 |
480 MHz Cortex-M7 240 MHz Cortex-M4 8 MB SDRAM 16 MB external Flash camera connector display connector dual 12-bit DAC audio jack |
For a camera project, start with one of Arduino’s supported camera modules and the bundled Camera library.
For an HMI, the GIGA Display Shield plus Arduino_H7_Video and LVGL is the easiest high-level route.
For audio, use Arduino_AdvancedAnalog when you need buffered, high-rate ADC/DAC operation, and always use a proper amplified audio output stage.
For full board pin mapping, see our Arduino GIGA R1 WiFi pinout guide. For splitting multimedia and real-time workloads between processors, see our GIGA R1 dual-core M7/M4 guide. For USB storage and peripherals, see the GIGA R1 USB Host guide.